package astar.model;

import java.util.ArrayList;
import java.io.FileWriter;  
import java.io.File;  
import java.io.IOException;

/**
*
* @author Artur Ataide, Andre Ventura
* @date Junho 2014
*
**/
public class Calc {

	private ArrayList<Double> pointTime;
	private ArrayList<Double> totalTime;
	private ArrayList<Double> algTime;
	private double avgTime;
	
	/**
	*
	* Construtor da classe que efetua os calculos dos tempos de execução.
	* São criados dois ArrayList, um com o tempo de execução do algoritmo
	* (ponto a ponto) e outro com a média dessas execuções.
	*
	*/
	public Calc(){
		this.pointTime = new ArrayList<Double>();
		this.algTime = new ArrayList<Double>();
		this.totalTime = new ArrayList<Double>();
		this.avgTime = 0;
	}

	/**
	*
	* Método que adiciona ao ArrayList o valor do tempo gasto a determinar um
	* ponto de menor custo. Ponto esse que vai entrar na lista fechada.
	*
	* @param time Tempo gasto pelo CPU a encontra o ponto com menor custo.
	*
	*/
	public void setPointTime(double time){
		this.pointTime.add(time);
	}

	/**
	*
	* Método que adiciona ao ArrayList o valor do tempo gasto a determinar todo
	* o caminho do algoritmo, acumulando esse tempo com os tempos obtidos anteriormente. 
	*
	* @param time Tempo gasto pelo CPU a encontra todo o caminho do algoritmo.
	*
	*/
	public void setTotalTime(double time){
		this.totalTime.add(time);
	}

	/**
	*
	* Método que adiciona ao ArrayList o valor do tempo gasto a determinar todo
	* o caminho do algoritmo. 
	*
	* @param time Tempo gasto pelo CPU a encontra todo o caminho do algoritmo.
	*
	*/
	public void setAlgTime(){
		this.algTime.add(this.calcAvg(this.pointTime));
		this.pointTime.clear();	
	}

	/**
	*
	* Métedo que retorna o ArrayList com os tempos de execução do algortimo.
	*
	* @return ArrayList com os tempos de execução do algoritmo.
	*
	*/
	public ArrayList<Double> getAlgTime(){
		return this.algTime;
	}

	/**
	*
	* Método que devolve o ArrayList com o tempo que o algoritmo demora a 
	* encontrar cada ponto.
	*
	* @return ArrayList com o tempo gasto a obter cada ponto
	*
	*/
	public ArrayList<Double> getPointTime(){
		return this.pointTime;
	}

	/**
	*
	* Métedo que retorna o ArrayList com os tempos acumulados de execução do algortimo.
	*
	* @return ArrayList com os tempos de execução acumulados do algoritmo.
	*
	*/
	public ArrayList<Double> getTotalTime(){
		return this.totalTime;
	}

	/**
	*
	* Métedo que retorna o valor médio que o algoritmo demora a encontrar um ponto.
	*
	* @return Valor médio que o algoritmo leva a encontrar um ponto.
	*
	*/
	public double getAvgTime(){
		return this.calcAvg(this.algTime);
	}

	/**
	*
	* Cálculo da média de tempos de cada execução do algoritmo.	
	*
	* @return A média de cada execução do algoritmo A*.
	*
	*/
	private double calcAvg(ArrayList<Double> calcAvg){
		double sum = 0;
 		for(double sumTime : calcAvg) {
 			sum += sumTime;
 		}
 		return (sum / calcAvg.size());
	}

	/**
	*
	* Método que grava num ficheiro de texto (.txt) as médias de tempos, para 
	* que posteriormente se possa desenhar o gráfico dessa média recorrento ao 
	* gnuplot.
	*
	*/
	public void saveToTxt(String name, ArrayList<Double> printArray){
		FileWriter arquivo;
		int w = 0;
		try { 
            arquivo = new FileWriter(new File(new java.io.File("astar/plot/" + name + ".txt").getAbsolutePath()));  
            for(double k : printArray) {
    			arquivo.write(w + " " + k + "\n");
    			w++;
    		}              
            arquivo.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
	}
}